package main

import (
	"fmt"
	"strconv"
	"unicode"
)

var step [10]struct {
    stage      int          // 当前阶段编号
    di, i, cdi chan pulse   // 不同类型的输入通道
    o          [6]chan pulse // 输出通道数组，大小为6
    csw        int          // 控制开关或标志位
    inff       int          // 可能是某种内部标志或计数器
    kludge     bool         // 用于标记某些特殊情况或补丁逻辑
}

var dec [20]struct {
    di    chan pulse // 输入脉冲通道
    val   int        // 存储某个整数值
    carry bool       // 表示是否需要进位或借位的标志
    lim   [6]int     // 一个包含6个整数的数组，可能用于存储某些限制或阈值
}

var assoc [8]int
var mpupdate chan int

func mpstat() string {
    var s string // 初始化一个空字符串 s 用于存储状态信息

    // 遍历 step 数组，获取每个元素的 stage 值并追加到字符串 s 中
    for i := 0; i < 10; i++ {
        s += fmt.Sprintf("%d", step[i].stage)
    }
    s += " " // 在字符串中添加一个空格分隔符

    // 遍历 dec 数组，获取每个元素的 val 值并追加到字符串 s 中
    for i := 0; i < 20; i++ {
        s += fmt.Sprintf("%d", dec[i].val)
    }
    s += " " // 再次添加一个空格分隔符

    // 遍历 step 数组，根据 inff 的值决定是否追加 "*" 或者具体的数值
    for i := 0; i < 10; i++ {
        if step[i].inff < 10 {
            s += fmt.Sprintf("%d", step[i].inff)
        } else {
            s += "*"
        }
    }

    return s // 返回最终的状态字符串
}

func mpreset() {
    // 遍历 dec 数组，重置 di 通道和 lim 数组
    for i := 0; i < 20; i++ {
        dec[i].di = nil // 将输入通道设置为 nil
        for j := 0; j < 6; j++ {
            dec[i].lim[j] = 0 // 将限制数组中的每个元素设置为 0
        }
    }

    // 遍历 step 数组，重置 di, i, cdi 通道以及 o 数组，同时重置 csw 和 kludge 标志位
    for i := 0; i < 10; i++ {
        step[i].di = nil
        step[i].i = nil
        step[i].cdi = nil
        for j := 0; j < 6; j++ {
            step[i].o[j] = nil // 将输出通道数组中的每个元素设置为 nil
        }
        step[i].csw = 0      // 重置控制开关
        step[i].kludge = false // 重置补丁逻辑标志位
    }

    // 重置 assoc 数组中的每个元素为 0
    for i := 0; i < 8; i++ {
        assoc[i] = 0
    }

    mpclear() // 调用 mpclear 函数进一步清理状态
    mpupdate <- 1 // 向 mpupdate 通道发送信号，通知状态更新
}

func mpclear() {
    // 遍历 dec 数组，重置 val 和 carry 标志位
    for i := 0; i < 20; i++ {
        dec[i].val = 0 // 将每个元素的 val 设置为 0
        dec[i].carry = false // 将 carry 标志位设置为 false
    }

    // 遍历 step 数组，重置 stage 和 inff 值
    for i := 0; i < 10; i++ {
        step[i].stage = 0 // 将每个元素的 stage 设置为 0
        step[i].inff = 0  // 将每个元素的 inff 设置为 0
    }
}

func mpplug(jack string, ch chan pulse) {
    var n int

    // 检查 jack 是否以数字开头，如果是，则解析为 dec 数组的索引
    if unicode.IsDigit(rune(jack[0])) {
        fmt.Sscanf(jack, "%ddi", &n) // 解析字符串，获取 n 的值
        dec[20-n].di = ch           // 将通道 ch 连接到 dec 数组的相应位置
    } else {
        // 如果 jack 不以数字开头，则将其视为程序标识符
        prog := int(jack[0] - 'A') // 计算程序编号
        if prog > 7 {               // 如果程序编号大于 7，则减去 1 以修正缺失的 I 程序
            prog--
        }

        // 根据 jack 字符串的后缀，将通道 ch 连接到相应的字段
        switch jack[1:] {
        case "di":
            step[prog].di = ch
        case "i":
            step[prog].i = ch
        case "cdi":
            step[prog].cdi = ch
        default:
            if len(jack) < 3 { // 如果字符串长度小于 3，则认为是无效的 MP jack
                fmt.Println("Invalid MP jack", jack)
                break
            }
            fmt.Sscanf(jack[1:], "%do", &n) // 解析字符串，获取 n 的值
            step[prog].o[n-1] = ch          // 将通道 ch 连接到 step 数组的相应输出通道
        }
    }

    mpupdate <- 1 // 向 mpupdate 通道发送信号，通知状态更新
}

func mpctl(ch chan [2]string) {
    var d, s int // 定义两个整数变量 d 和 s，用于存储从控制指令中解析出的数值

    for {
        ctl := <-ch // 从通道 ch 接收控制指令，ctl 是一个包含两个字符串的数组
        switch ctl[0][0] { // 根据第一个字符串的第一个字符进行分支处理
        case 'a', 'A': // 如果第一个字符是 'a' 或 'A'
            switch ctl[0] { // 进一步根据整个第一个字符串进行细分
            case "a20", "A20":
                if ctl[1] == "b" || ctl[1] == "B" { // 如果第二个字符串是 "b" 或 "B"
                    assoc[0] = 1 // 设置 assoc 数组的第一个元素为 1
                } else {
                    assoc[0] = 0 // 否则设置为 0
                }
            case "a18", "A18":
                if ctl[1] == "c" || ctl[1] == "C" {
                    assoc[1] = 1
                } else {
                    assoc[1] = 0
                }
            case "a14", "A14":
                if ctl[1] == "d" || ctl[1] == "D" {
                    assoc[2] = 1
                } else {
                    assoc[2] = 0
                }
            case "a12", "A12":
                if ctl[1] == "e" || ctl[1] == "E" {
                    assoc[3] = 1
                } else {
                    assoc[3] = 0
                }
            case "a10", "A10":
                if ctl[1] == "g" || ctl[1] == "G" {
                    assoc[4] = 1
                } else {
                    assoc[4] = 0
                }
            case "a8", "A8":
                if ctl[1] == "h" || ctl[1] == "H" {
                    assoc[5] = 1
                } else {
                    assoc[5] = 0
                }
            case "a4", "A4":
                if ctl[1] == "j" || ctl[1] == "J" {
                    assoc[6] = 1
                } else {
                    assoc[6] = 0
                }
            case "a2", "A2":
                if ctl[1] == "k" || ctl[1] == "K" {
                    assoc[7] = 1
                } else {
                    assoc[7] = 0
                }
            default:
                fmt.Printf("Invalid MP associator switch %s\n", ctl[0]) // 如果第一个字符串不符合任何已知模式，打印错误信息
                break
            }

        case 'd', 'D': // 如果第一个字符是 'd' 或 'D'
            fmt.Sscanf(ctl[0], "d%ds%d", &d, &s) // 解析第一个字符串，获取 d 和 s 的值
            n, _ := strconv.Atoi(ctl[1]) // 将第二个字符串转换为整数 n
            dec[20-d].lim[s-1] = n // 更新 dec 数组中相应位置的 lim 值

        case 'c', 'C': // 如果第一个字符是 'c' 或 'C'
            s = int(ctl[0][1] - 'A') // 计算程序编号 s
            if s > 7 { // 如果程序编号大于 7，则减去 1 以修正缺失的 I 程序
                s--
            }
            n, _ := strconv.Atoi(ctl[1]) // 将第二个字符串转换为整数 n
            step[s].csw = n - 1 // 更新 step 数组中相应位置的 csw 值

        default:
            fmt.Printf("Invalid master programmer switch %s\n", ctl[0]) // 如果第一个字符不符合任何已知模式，打印错误信息
        }
    }
}

func incstep(st int) {
    // 检查当前阶段是否设置了 kludge 标志
    if step[st].kludge {
        return // 如果设置了 kludge 标志，则直接返回，不执行后续操作
    }

    // 检查当前 stage 是否大于等于 csw（控制开关值）
    if step[st].stage >= step[st].csw {
        step[st].stage = 0 // 如果 stage 大于等于 csw，则将 stage 重置为 0
    } else {
        step[st].stage++ // 否则，递增 stage 值
    }

    // 设置 kludge 标志，防止重复执行
    step[st].kludge = true
}

func cycgate(st int) bool {
    // 获取当前阶段的 stage 值
    stage := step[st].stage 

    // 根据阶段编号进行分支处理
    switch st {
    case 0:
        // 如果 assoc[0] 为 1，则返回 false
        if assoc[0] == 1 {
            return false
        } else {
            // 否则检查 dec[0].val 是否等于其限制值
            return dec[0].val == dec[0].lim[stage]
        }

    case 1:
        // 如果 assoc[1] 为 0 并且 dec[2].val 不等于其限制值，则返回 false
        if assoc[1] == 0 && dec[2].val != dec[2].lim[stage] {
            return false
        // 检查 dec[1].val 是否等于其限制值
        } else if dec[1].val != dec[1].lim[stage] {
            return false
        // 如果 assoc[0] 为 1 并且 dec[0].val 不等于其限制值，则返回 false
        } else if assoc[0] == 1 && dec[0].val != dec[0].lim[stage] {
            return false
        }
        // 所有条件都满足时返回 true
        return true

    case 2:
        // 如果 assoc[2] 为 0 并且 dec[6].val 不等于其限制值，则返回 false
        if assoc[2] == 0 && dec[6].val != dec[6].lim[stage] {
            return false
        // 检查 dec[5].val 是否等于其限制值
        } else if dec[5].val != dec[5].lim[stage] {
            return false
        // 检查 dec[4].val 是否等于其限制值
        } else if dec[4].val != dec[4].lim[stage] {
            return false
        // 检查 dec[3].val 是否等于其限制值
        } else if dec[3].val != dec[3].lim[stage] {
            return false
        // 如果 assoc[1] 为 1 并且 dec[2].val 不等于其限制值，则返回 false
        } else if assoc[1] == 1 && dec[2].val != dec[2].lim[stage] {
            return false
        }
        // 所有条件都满足时返回 true
        return true

    case 3:
        // 如果 assoc[3] 为 0 并且 dec[8].val 不等于其限制值，则返回 false
        if assoc[3] == 0 && dec[8].val != dec[8].lim[stage] {
            return false
        // 检查 dec[7].val 是否等于其限制值
        } else if dec[7].val != dec[7].lim[stage] {
            return false
        // 如果 assoc[2] 为 1 并且 dec[6].val 不等于其限制值，则返回 false
        } else if assoc[2] == 1 && dec[6].val != dec[6].lim[stage] {
            return false
        }
        // 所有条件都满足时返回 true
        return true

    case 4:
        // 如果 assoc[3] 为 0，则仅检查 dec[9].val 是否等于其限制值
        if assoc[3] == 0 {
            return dec[9].val == dec[9].lim[stage]
        } else {
            // 否则需要同时检查 dec[9].val 和 dec[8].val 是否等于其限制值
            return dec[9].val == dec[9].lim[stage] &&
                dec[8].val == dec[8].lim[stage]
        }

    case 5:
        // 如果 assoc[4] 为 1，则返回 false
        if assoc[4] == 1 {
            return false
        } else {
            // 否则检查 dec[10].val 是否等于其限制值
            return dec[10].val == dec[10].lim[stage]
        }

    case 6:
        // 如果 assoc[5] 为 0 并且 dec[12].val 不等于其限制值，则返回 false
        if assoc[5] == 0 && dec[12].val != dec[12].lim[stage] {
            return false
        // 检查 dec[11].val 是否等于其限制值
        } else if dec[11].val != dec[11].lim[stage] {
            return false
        // 如果 assoc[4] 为 1 并且 dec[10].val 不等于其限制值，则返回 false
        } else if assoc[4] == 1 && dec[10].val != dec[10].lim[stage] {
            return false
        }
        // 所有条件都满足时返回 true
        return true

    case 7:
        // 如果 assoc[6] 为 0 并且 dec[16].val 不等于其限制值，则返回 false
        if assoc[6] == 0 && dec[16].val != dec[16].lim[stage] {
            return false
        // 检查 dec[15].val 是否等于其限制值
        } else if dec[15].val != dec[15].lim[stage] {
            return false
        // 检查 dec[14].val 是否等于其限制值
        } else if dec[14].val != dec[14].lim[stage] {
            return false
        // 检查 dec[13].val 是否等于其限制值
        } else if dec[13].val != dec[13].lim[stage] {
            return false
        // 如果 assoc[5] 为 1 并且 dec[12].val 不等于其限制值，则返回 false
        } else if assoc[5] == 1 && dec[12].val != dec[12].lim[stage] {
            return false
        }
        // 所有条件都满足时返回 true
        return true

    case 8:
        // 如果 assoc[7] 为 0 并且 dec[18].val 不等于其限制值，则返回 false
        if assoc[7] == 0 && dec[18].val != dec[18].lim[stage] {
            return false
        // 检查 dec[17].val 是否等于其限制值
        } else if dec[17].val != dec[17].lim[stage] {
            return false
        // 如果 assoc[6] 为 1 并且 dec[16].val 不等于其限制值，则返回 false
        } else if assoc[6] == 1 && dec[16].val != dec[16].lim[stage] {
            return false
        }
        // 所有条件都满足时返回 true
        return true

    case 9:
        // 如果 assoc[7] 为 0，则仅检查 dec[19].val 是否等于其限制值
        if assoc[7] == 0 {
            return dec[19].val == dec[19].lim[stage]
        } else {
            // 否则需要同时检查 dec[19].val 和 dec[18].val 是否等于其限制值
            return dec[19].val == dec[19].lim[stage] &&
                dec[18].val == dec[18].lim[stage]
        }
    }

    // 默认情况下返回 false
    return false
}

func incdec(de int) {
    // 将 dec[de].val 的值加 1
    dec[de].val++

    // 检查 dec[de].val 是否等于 10
    if dec[de].val == 10 {
        // 如果是，则将 dec[de].val 重置为 0
        dec[de].val = 0
        // 设置 carry 标志为 true，表示发生了进位
        dec[de].carry = true
    }
}

func clrdecset(st int) {
    // 根据阶段编号 st 进行分支处理
    switch st {
    case 0:
        // 如果 assoc[0] 为 0，则重置 dec[0] 的 val 和 carry
        if assoc[0] == 0 {
            dec[0].val = 0
            dec[0].carry = false
        }

    case 1:
        // 如果 assoc[0] 为 1，则重置 dec[0] 的 val 和 carry
        if assoc[0] == 1 {
            dec[0].val = 0
            dec[0].carry = false
        }
        // 无论条件如何，始终重置 dec[1] 的 val 和 carry
        dec[1].val = 0
        dec[1].carry = false
        // 如果 assoc[1] 为 0，则重置 dec[2] 的 val 和 carry
        if assoc[1] == 0 {
            dec[2].val = 0
            dec[2].carry = false
        }

    case 2:
        // 如果 assoc[1] 为 1，则重置 dec[2] 的 val 和 carry
        if assoc[1] == 1 {
            dec[2].val = 0
            dec[2].carry = false
        }
        // 无论条件如何，始终重置 dec[3], dec[4], dec[5] 的 val 和 carry
        dec[3].val = 0
        dec[3].carry = false
        dec[4].val = 0
        dec[4].carry = false
        dec[5].val = 0
        dec[5].carry = false
        // 如果 assoc[2] 为 0，则重置 dec[6] 的 val 和 carry
        if assoc[2] == 0 {
            dec[6].val = 0
            dec[6].carry = false
        }

    case 3:
        // 如果 assoc[2] 为 1，则重置 dec[6] 的 val 和 carry
        if assoc[2] == 1 {
            dec[6].val = 0
            dec[6].carry = false
        }
        // 无论条件如何，始终重置 dec[7] 的 val 和 carry
        dec[7].val = 0
        dec[7].carry = false
        // 如果 assoc[3] 为 0，则重置 dec[8] 的 val 和 carry
        if assoc[3] == 0 {
            dec[8].val = 0
            dec[8].carry = false
        }

    case 4:
        // 如果 assoc[3] 为 1，则重置 dec[8] 的 val 和 carry
        if assoc[3] == 1 {
            dec[8].val = 0
            dec[8].carry = false
        }
        // 无论条件如何，始终重置 dec[9] 的 val 和 carry
        dec[9].val = 0
        dec[9].carry = false

    case 5:
        // 如果 assoc[4] 为 0，则重置 dec[10] 的 val 和 carry
        if assoc[4] == 0 {
            dec[10].val = 0
            dec[10].carry = false
        }

    case 6:
        // 如果 assoc[4] 为 1，则重置 dec[10] 的 val 和 carry
        if assoc[4] == 1 {
            dec[10].val = 0
            dec[10].carry = false
        }
        // 无论条件如何，始终重置 dec[11] 的 val 和 carry
        dec[11].val = 0
        dec[11].carry = false
        // 如果 assoc[5] 为 0，则重置 dec[12] 的 val 和 carry
        if assoc[5] == 0 {
            dec[12].val = 0
            dec[12].carry = false
        }

    case 7:
        // 如果 assoc[5] 为 1，则重置 dec[12] 的 val 和 carry
        if assoc[5] == 1 {
            dec[12].val = 0
            dec[12].carry = false
        }
        // 无论条件如何，始终重置 dec[13], dec[14], dec[15] 的 val 和 carry
        dec[13].val = 0
        dec[13].carry = false
        dec[14].val = 0
        dec[14].carry = false
        dec[15].val = 0
        dec[15].carry = false
        // 如果 assoc[6] 为 0，则重置 dec[16] 的 val 和 carry
        if assoc[6] == 0 {
            dec[16].val = 0
            dec[16].carry = false
        }

    case 8:
        // 如果 assoc[6] 为 1，则重置 dec[16] 的 val 和 carry
        if assoc[6] == 1 {
            dec[16].val = 0
            dec[16].carry = false
        }
        // 无论条件如何，始终重置 dec[17] 的 val 和 carry
        dec[17].val = 0
        dec[17].carry = false
        // 如果 assoc[7] 为 0，则重置 dec[18] 的 val 和 carry
        if assoc[7] == 0 {
            dec[18].val = 0
            dec[18].carry = false
        }

    case 9:
        // 如果 assoc[7] 为 1，则重置 dec[18] 的 val 和 carry
        if assoc[7] == 1 {
            dec[18].val = 0
            dec[18].carry = false
        }
        // 无论条件如何，始终重置 dec[19] 的 val 和 carry
        dec[19].val = 0
        dec[19].carry = false
    }
}

func incdecset(st int) {
    // 根据阶段编号 st 进行分支处理
    switch st {
    case 0:
        // 如果 assoc[0] 为 0，则递增 dec[0]
        if assoc[0] == 0 {
            incdec(0)
        }

    case 1:
        // 如果 assoc[1] 为 0，则递增 dec[2]
        if assoc[1] == 0 {
            incdec(2)
            // 如果 dec[2] 发生了进位，则递增 dec[1] 并清除 dec[2] 的 carry 标志
            if dec[2].carry {
                incdec(1)
                dec[2].carry = false
            }
        } else {
            // 否则直接递增 dec[1]
            incdec(1)
        }
        // 如果 assoc[0] 为 1 且 dec[1] 发生了进位，则递增 dec[0] 并清除 dec[1] 的 carry 标志
        if assoc[0] == 1 && dec[1].carry {
            incdec(0)
            dec[1].carry = false
        }

    case 2:
        // 如果 assoc[2] 为 0，则递增 dec[6]
        if assoc[2] == 0 {
            incdec(6)
            // 如果 dec[6] 发生了进位，则递增 dec[5] 并清除 dec[6] 的 carry 标志
            if dec[6].carry {
                incdec(5)
                dec[6].carry = false
            }
        } else {
            // 否则直接递增 dec[5]
            incdec(5)
        }
        // 如果 dec[5] 发生了进位，则递增 dec[4] 并清除 dec[5] 的 carry 标志
        if dec[5].carry {
            incdec(4)
            dec[5].carry = false
        }
        // 如果 dec[4] 发生了进位，则递增 dec[3] 并清除 dec[4] 的 carry 标志
        if dec[4].carry {
            incdec(3)
            dec[4].carry = false
        }
        // 如果 assoc[1] 为 1 且 dec[3] 发生了进位，则递增 dec[2] 并清除 dec[3] 的 carry 标志
        if assoc[1] == 1 && dec[3].carry {
            incdec(2)
            dec[3].carry = false
        }

    case 3:
        // 如果 assoc[3] 为 0，则递增 dec[8]
        if assoc[3] == 0 {
            incdec(8)
            // 如果 dec[8] 发生了进位，则递增 dec[7] 并清除 dec[8] 的 carry 标志
            if dec[8].carry {
                incdec(7)
                dec[8].carry = false
            }
        } else {
            // 否则直接递增 dec[7]
            incdec(7)
        }
        // 如果 assoc[2] 为 1 且 dec[8] 发生了进位，则递增 dec[7] 并清除 dec[8] 的 carry 标志
        if assoc[2] == 1 && dec[8].carry {
            incdec(7)
            dec[8].carry = false
        }

    case 4:
        // 递增 dec[9]
        incdec(9)
        // 如果 assoc[3] 为 1 且 dec[9] 发生了进位，则递增 dec[8] 并清除 dec[9] 的 carry 标志
        if assoc[3] == 1 && dec[9].carry {
            incdec(8)
            dec[9].carry = false
        }

    case 5:
        // 如果 assoc[4] 为 0，则递增 dec[10]
        if assoc[4] == 0 {
            incdec(10)
        }

    case 6:
        // 如果 assoc[5] 为 0，则递增 dec[12]
        if assoc[5] == 0 {
            incdec(12)
            // 如果 dec[12] 发生了进位，则递增 dec[11] 并清除 dec[12] 的 carry 标志
            if dec[12].carry {
                incdec(11)
                dec[12].carry = false
            }
        } else {
            // 否则直接递增 dec[11]
            incdec(11)
        }
        // 如果 assoc[4] 为 1 且 dec[11] 发生了进位，则递增 dec[10] 并清除 dec[11] 的 carry 标志
        if assoc[4] == 1 && dec[11].carry {
            incdec(10)
            dec[11].carry = false
        }

    case 7:
        // 如果 assoc[6] 为 0，则递增 dec[16]
        if assoc[6] == 0 {
            incdec(16)
            // 如果 dec[16] 发生了进位，则递增 dec[15] 并清除 dec[16] 的 carry 标志
            if dec[16].carry {
                incdec(15)
                dec[16].carry = false
            }
        } else {
            // 否则直接递增 dec[15]
            incdec(15)
        }
        // 如果 dec[15] 发生了进位，则递增 dec[14] 并清除 dec[15] 的 carry 标志
        if dec[15].carry {
            incdec(14)
            dec[15].carry = false
        }
        // 如果 dec[14] 发生了进位，则递增 dec[13] 并清除 dec[14] 的 carry 标志
        if dec[14].carry {
            incdec(13)
            dec[14].carry = false
        }
        // 如果 assoc[5] 为 1 且 dec[13] 发生了进位，则递增 dec[12] 并清除 dec[13] 的 carry 标志
        if assoc[5] == 1 && dec[13].carry {
            incdec(12)
            dec[13].carry = false
        }

    case 8:
        // 如果 assoc[7] 为 0，则递增 dec[18]
        if assoc[7] == 0 {
            incdec(18)
            // 如果 dec[18] 发生了进位，则递增 dec[17] 并清除 dec[18] 的 carry 标志
            if dec[18].carry {
                incdec(17)
                dec[18].carry = false
            }
        } else {
            // 否则直接递增 dec[17]
            incdec(17)
        }
        // 如果 assoc[6] 为 1 且 dec[18] 发生了进位，则递增 dec[17] 并清除 dec[18] 的 carry 标志
        if assoc[6] == 1 && dec[18].carry {
            incdec(17)
            dec[18].carry = false
        }

    case 9:
        // 递增 dec[19]
        incdec(19)
        // 如果 assoc[7] 为 1 且 dec[19] 发生了进位，则递增 dec[18] 并清除 dec[19] 的 carry 标志
        if assoc[7] == 1 && dec[19].carry {
            incdec(18)
            dec[19].carry = false
        }
    }
}

// 该函数用于处理从通道 cyctrunk 接收到的脉冲 (pulse) 信息，并根据不同的条件执行相应的操作。
// 它通过循环不断监听来自 cyctrunk 的脉冲，并根据脉冲的值进行不同的处理逻辑
func mpunit(cyctrunk chan pulse) {
    var p pulse

    // 初始化 mpupdate 通道并启动 mpunit2 协程
    mpupdate = make(chan int)
    go mpunit2()

    // 创建响应通道 resp
    resp := make(chan int)

    // 持续监听 cyctrunk 通道中的脉冲
    for {
        // 从 cyctrunk 通道接收脉冲 p
        p = <-cyctrunk
        cyc := p.val

        // 如果脉冲值包含 Cpp 标志
        if cyc&Cpp != 0 {
            // 遍历所有的 step 元素
            for i, s := range step {
                // 调用 cycgate 函数检查是否满足某些条件
                if cycgate(i) {
                    // 如果满足条件，则调用 clrdecset 和 incstep 函数
                    clrdecset(i)
                    incstep(i)
                }
                // 如果 step[i].inff 大于等于 6（可能是 > 3 and < 12）
                if s.inff >= 6 {
                    // 调用 incdecset 函数并重置 inff 值
                    incdecset(i)
                    step[i].inff = 0
                    // 如果当前阶段有输出通道且不为空，则发送脉冲并等待响应
                    if s.o[s.stage] != nil {
                        s.o[s.stage] <- pulse{1, resp}
                        <-resp
                    }
                }
            }
        } else if cyc&Tenp != 0 { // 如果脉冲值包含 Tenp 标志
            // 将所有 step 的 kludge 标志设置为 false
            for i := 0; i < len(step); i++ {
                step[i].kludge = false
            }
        }

        // 如果接收到的脉冲包含响应通道，则向其发送 1
        if p.resp != nil {
            p.resp <- 1
        }

        // 模拟 "flip-flop...time constant approximately equal to that of the slow buffer output of a transceiver."
        // 对所有 step 元素的 inff 值进行递增
        for i, s := range step {
            if s.inff > 0 {
                step[i].inff++
            }
        }
    }
}

func mpunit2() {
	var p pulse
	// 无限循环，持续监听各个通道
	for {
		select {
		case <-mpupdate:
			// 处理 mpupdate 通道的消息，当前实现为空
		case p = <-dec[0].di:
			// 如果从 dec[0].di 接收到消息，则递增 dec[0] 并响应
			incdec(0)
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-dec[1].di:
			incdec(1)
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-dec[2].di:
			incdec(2)
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-dec[3].di:
			incdec(3)
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-dec[4].di:
			incdec(4)
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-dec[5].di:
			incdec(5)
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-dec[6].di:
			incdec(6)
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-dec[7].di:
			incdec(7)
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-dec[8].di:
			incdec(8)
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-dec[9].di:
			incdec(9)
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-dec[10].di:
			incdec(10)
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-dec[11].di:
			incdec(11)
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-dec[12].di:
			incdec(12)
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-dec[13].di:
			incdec(13)
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-dec[14].di:
			incdec(14)
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-dec[15].di:
			incdec(15)
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-dec[16].di:
			incdec(16)
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-dec[17].di:
			incdec(17)
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-dec[18].di:
			incdec(18)
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-dec[19].di:
			incdec(19)
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-step[0].di:
			incstep(0)
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-step[0].i:
			step[0].inff = 1
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-step[0].cdi:
			step[0].stage = 0
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-step[1].di:
			incstep(1)
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-step[1].i:
			step[1].inff = 1
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-step[1].cdi:
			step[1].stage = 0
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-step[2].di:
			incstep(2)
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-step[2].i:
			step[2].inff = 1
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-step[2].cdi:
			step[2].stage = 0
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-step[3].di:
			incstep(3)
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-step[3].i:
			step[3].inff = 1
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-step[3].cdi:
			step[3].stage = 0
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-step[4].di:
			incstep(4)
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-step[4].i:
			step[4].inff = 1
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-step[4].cdi:
			step[4].stage = 0
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-step[5].di:
			incstep(5)
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-step[5].i:
			step[5].inff = 1
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-step[5].cdi:
			step[5].stage = 0
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-step[6].di:
			incstep(6)
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-step[6].i:
			step[6].inff = 1
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-step[6].cdi:
			step[6].stage = 0
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-step[7].di:
			incstep(7)
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-step[7].i:
			step[7].inff = 1
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-step[7].cdi:
			step[7].stage = 0
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-step[8].di:
			incstep(8)
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-step[8].i:
			step[8].inff = 1
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-step[8].cdi:
			step[8].stage = 0
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-step[9].di:
			incstep(9)
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-step[9].i:
			step[9].inff = 1
			if p.resp != nil {
				p.resp <- 1
			}
		case p = <-step[9].cdi:
			step[9].stage = 0
			if p.resp != nil {
				p.resp <- 1
			}
		}
	}
}
